---
layout: "default"
title: "Operator: =="
description: "Swift documentation for the '==' operator."
root: "/v2.2"
---

<code class="language-swift">infix operator == {
    associativity none
    precedence 130
}</code>

<h3>Declarations</h3>

<div class="declaration" id="func-eqeq_-swiftnsoperatingsystemversion-rhs_-swiftnsoperatingsystemversion">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-swiftnsoperatingsystemversion-rhs_-swiftnsoperatingsystemversion">func ==(<wbr>_:<wbr> _SwiftNSOperatingSystemVersion, rhs: _SwiftNSOperatingSystemVersion)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-swiftnsoperatingsystemversion-rhs_-swiftnsoperatingsystemversion"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: _SwiftNSOperatingSystemVersion, rhs: _SwiftNSOperatingSystemVersion) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-anybidirectionalindex-rhs_-anybidirectionalindex">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-anybidirectionalindex-rhs_-anybidirectionalindex">func ==(<wbr>_:<wbr> AnyBidirectionalIndex, rhs: AnyBidirectionalIndex)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-anybidirectionalindex-rhs_-anybidirectionalindex"><div class="p">
    <p>Returns <code>true</code> iff <code>lhs</code> and <code>rhs</code> wrap equal underlying
<code>AnyBidirectionalIndex</code>s.</p>

<p><strong>Requires:</strong> The types of indices wrapped by <code>lhs</code> and <code>rhs</code> are
  identical.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: AnyBidirectionalIndex, rhs: AnyBidirectionalIndex) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-anyforwardindex-rhs_-anyforwardindex">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-anyforwardindex-rhs_-anyforwardindex">func ==(<wbr>_:<wbr> AnyForwardIndex, rhs: AnyForwardIndex)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-anyforwardindex-rhs_-anyforwardindex"><div class="p">
    <p>Returns <code>true</code> iff <code>lhs</code> and <code>rhs</code> wrap equal underlying
<code>AnyForwardIndex</code>s.</p>

<p><strong>Requires:</strong> The types of indices wrapped by <code>lhs</code> and <code>rhs</code> are
  identical.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: AnyForwardIndex, rhs: AnyForwardIndex) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-anyrandomaccessindex-rhs_-anyrandomaccessindex">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-anyrandomaccessindex-rhs_-anyrandomaccessindex">func ==(<wbr>_:<wbr> AnyRandomAccessIndex, rhs: AnyRandomAccessIndex)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-anyrandomaccessindex-rhs_-anyrandomaccessindex"><div class="p">
    <p>Returns <code>true</code> iff <code>lhs</code> and <code>rhs</code> wrap equal underlying
<code>AnyRandomAccessIndex</code>s.</p>

<p><strong>Requires:</strong> The types of indices wrapped by <code>lhs</code> and <code>rhs</code> are
  identical.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: AnyRandomAccessIndex, rhs: AnyRandomAccessIndex) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-bit-rhs_-bit">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-bit-rhs_-bit">func ==(<wbr>_:<wbr> Bit, rhs: Bit)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-bit-rhs_-bit"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Bit, rhs: Bit) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-bool-rhs_-bool">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-bool-rhs_-bool">func ==(<wbr>_:<wbr> Bool, rhs: Bool)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-bool-rhs_-bool"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Bool, rhs: Bool) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-copaquepointer-rhs_-copaquepointer">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-copaquepointer-rhs_-copaquepointer">func ==(<wbr>_:<wbr> COpaquePointer, rhs: COpaquePointer)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-copaquepointer-rhs_-copaquepointer"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: COpaquePointer, rhs: COpaquePointer) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-character-rhs_-character">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-character-rhs_-character">func ==(<wbr>_:<wbr> Character, rhs: Character)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-character-rhs_-character"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Character, rhs: Character) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-double-rhs_-double">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-double-rhs_-double">func ==(<wbr>_:<wbr> Double, rhs: Double)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-double-rhs_-double"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Double, rhs: Double) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-float-rhs_-float">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-float-rhs_-float">func ==(<wbr>_:<wbr> Float, rhs: Float)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-float-rhs_-float"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Float, rhs: Float) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-float80-rhs_-float80">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-float80-rhs_-float80">func ==(<wbr>_:<wbr> Float80, rhs: Float80)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-float80-rhs_-float80"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Float80, rhs: Float80) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-index-rhs_-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-index-rhs_-index">func ==(<wbr>_:<wbr> Index, rhs: Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-index-rhs_-index"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Index, rhs: Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int-rhs_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int-rhs_-int">func ==(<wbr>_:<wbr> Int, rhs: Int)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int-rhs_-int"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int, rhs: Int) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int8-rhs_-int8">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int8-rhs_-int8">func ==(<wbr>_:<wbr> Int8, rhs: Int8)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int8-rhs_-int8"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int8, rhs: Int8) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int16-rhs_-int16">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int16-rhs_-int16">func ==(<wbr>_:<wbr> Int16, rhs: Int16)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int16-rhs_-int16"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int16, rhs: Int16) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int32-rhs_-int32">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int32-rhs_-int32">func ==(<wbr>_:<wbr> Int32, rhs: Int32)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int32-rhs_-int32"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int32, rhs: Int32) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int64-rhs_-int64">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int64-rhs_-int64">func ==(<wbr>_:<wbr> Int64, rhs: Int64)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int64-rhs_-int64"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int64, rhs: Int64) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-string-rhs_-string">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-string-rhs_-string">func ==(<wbr>_:<wbr> String, rhs: String)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-string-rhs_-string"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: String, rhs: String) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-string-utf8view-index-rhs_-string-utf8view-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-string-utf8view-index-rhs_-string-utf8view-index">func ==(<wbr>_:<wbr> String.UTF8View.Index, rhs: String.UTF8View.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-string-utf8view-index-rhs_-string-utf8view-index"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: String.UTF8View.Index, rhs: String.UTF8View.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-string-utf16view-index-rhs_-string-utf16view-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-string-utf16view-index-rhs_-string-utf16view-index">func ==(<wbr>_:<wbr> String.UTF16View.Index, rhs: String.UTF16View.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-string-utf16view-index-rhs_-string-utf16view-index"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: String.UTF16View.Index, rhs: String.UTF16View.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-string-unicodescalarview-index-rhs_-string-unicodescalarview-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-string-unicodescalarview-index-rhs_-string-unicodescalarview-index">func ==(<wbr>_:<wbr> String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-string-unicodescalarview-index-rhs_-string-unicodescalarview-index"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint-rhs_-uint">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint-rhs_-uint">func ==(<wbr>_:<wbr> UInt, rhs: UInt)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint-rhs_-uint"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt, rhs: UInt) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint8-rhs_-uint8">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint8-rhs_-uint8">func ==(<wbr>_:<wbr> UInt8, rhs: UInt8)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint8-rhs_-uint8"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt8, rhs: UInt8) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint16-rhs_-uint16">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint16-rhs_-uint16">func ==(<wbr>_:<wbr> UInt16, rhs: UInt16)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint16-rhs_-uint16"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt16, rhs: UInt16) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint32-rhs_-uint32">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint32-rhs_-uint32">func ==(<wbr>_:<wbr> UInt32, rhs: UInt32)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint32-rhs_-uint32"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt32, rhs: UInt32) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint64-rhs_-uint64">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint64-rhs_-uint64">func ==(<wbr>_:<wbr> UInt64, rhs: UInt64)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint64-rhs_-uint64"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt64, rhs: UInt64) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unicodescalar-rhs_-unicodescalar">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unicodescalar-rhs_-unicodescalar">func ==(<wbr>_:<wbr> UnicodeScalar, rhs: UnicodeScalar)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unicodescalar-rhs_-unicodescalar"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UnicodeScalar, rhs: UnicodeScalar) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-any-type-t1_-any-type">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-any-type-t1_-any-type">func ==(<wbr>_:<wbr> Any.Type?, t1: Any.Type?)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-any-type-t1_-any-type"><div class="p">
    <p>Returns <code>true</code> iff <code>t0</code> is identical to <code>t1</code>; i.e. if they are both
<code>nil</code> or they both represent the same type.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(t0: Any.Type?, t1: Any.Type?) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-objectidentifier-y_-objectidentifier">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-objectidentifier-y_-objectidentifier">func ==(<wbr>_:<wbr> ObjectIdentifier, y: ObjectIdentifier)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-objectidentifier-y_-objectidentifier"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: ObjectIdentifier, y: ObjectIdentifier) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable-e_-equatable-f_-equatable_-a-b-c-d-e-f-rhs_-a-b-c-d-e-f">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable-e_-equatable-f_-equatable_-a-b-c-d-e-f-rhs_-a-b-c-d-e-f">func <wbr>== &lt;A :<wbr> Equatable, B :<wbr> Equatable, C :<wbr> Equatable, D :<wbr> Equatable, E :<wbr> Equatable, F : Equatable&gt;(<wbr>_: (<wbr>A, B, C, D, E, F), rhs: (A, B, C, D, E, F))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable-e_-equatable-f_-equatable_-a-b-c-d-e-f-rhs_-a-b-c-d-e-f"><div class="p">
    <p>Returns <code>true</code> iff each component of <code>lhs</code> is equal to the corresponding
component of <code>rhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable&gt;(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable-e_-equatable_-a-b-c-d-e-rhs_-a-b-c-d-e">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable-e_-equatable_-a-b-c-d-e-rhs_-a-b-c-d-e">func <wbr>== &lt;A :<wbr> Equatable, B :<wbr> Equatable, C :<wbr> Equatable, D :<wbr> Equatable, E : Equatable&gt;(<wbr>_: (<wbr>A, B, C, D, E), rhs: (A, B, C, D, E))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable-e_-equatable_-a-b-c-d-e-rhs_-a-b-c-d-e"><div class="p">
    <p>Returns <code>true</code> iff each component of <code>lhs</code> is equal to the corresponding
component of <code>rhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable&gt;(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable_-a-b-c-d-rhs_-a-b-c-d">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable_-a-b-c-d-rhs_-a-b-c-d">func <wbr>== &lt;A :<wbr> Equatable, B :<wbr> Equatable, C :<wbr> Equatable, D : Equatable&gt;(<wbr>_: (<wbr>A, B, C, D), rhs: (A, B, C, D))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable-d_-equatable_-a-b-c-d-rhs_-a-b-c-d"><div class="p">
    <p>Returns <code>true</code> iff each component of <code>lhs</code> is equal to the corresponding
component of <code>rhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A : Equatable, B : Equatable, C : Equatable, D : Equatable&gt;(lhs: (A, B, C, D), rhs: (A, B, C, D)) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a_-equatable-b_-equatable-c_-equatable_-a-b-c-rhs_-a-b-c">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable_-a-b-c-rhs_-a-b-c">func <wbr>== &lt;A :<wbr> Equatable, B :<wbr> Equatable, C : Equatable&gt;(<wbr>_: (<wbr>A, B, C), rhs: (A, B, C))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a_-equatable-b_-equatable-c_-equatable_-a-b-c-rhs_-a-b-c"><div class="p">
    <p>Returns <code>true</code> iff each component of <code>lhs</code> is equal to the corresponding
component of <code>rhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A : Equatable, B : Equatable, C : Equatable&gt;(lhs: (A, B, C), rhs: (A, B, C)) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a_-equatable-b_-equatable_-a-b-rhs_-a-b">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a_-equatable-b_-equatable_-a-b-rhs_-a-b">func <wbr>== &lt;A :<wbr> Equatable, B : Equatable&gt;(<wbr>_: (<wbr>A, B), rhs: (A, B))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a_-equatable-b_-equatable_-a-b-rhs_-a-b"><div class="p">
    <p>Returns <code>true</code> iff each component of <code>lhs</code> is equal to the corresponding
component of <code>rhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A : Equatable, B : Equatable&gt;(lhs: (A, B), rhs: (A, B)) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-base_-collectiontype_-lazyfilterindex-base-rhs_-lazyfilterindex-base">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-base_-collectiontype_-lazyfilterindex-base-rhs_-lazyfilterindex-base">func <wbr>== &lt;Base : CollectionType&gt;(<wbr>_:<wbr> LazyFilterIndex&lt;Base&gt;, rhs: LazyFilterIndex&lt;Base&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-base_-collectiontype_-lazyfilterindex-base-rhs_-lazyfilterindex-base"><div class="p">
    <p>Returns <code>true</code> iff <code>lhs</code> is identical to <code>rhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Base : CollectionType&gt;(lhs: LazyFilterIndex&lt;Base&gt;, rhs: LazyFilterIndex&lt;Base&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-base_-reverseindex-base-rhs_-reverseindex-base">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-base_-reverseindex-base-rhs_-reverseindex-base">func == &lt;Base&gt;(<wbr>_:<wbr> ReverseIndex&lt;Base&gt;, rhs: ReverseIndex&lt;Base&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-base_-reverseindex-base-rhs_-reverseindex-base"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Base&gt;(lhs: ReverseIndex&lt;Base&gt;, rhs: ReverseIndex&lt;Base&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-baseelements_-flattenbidirectionalcollectionindex-baseelements-rhs_-flattenbidirectionalcollectionindex-baseelements">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-baseelements_-flattenbidirectionalcollectionindex-baseelements-rhs_-flattenbidirectionalcollectionindex-baseelements">func == &lt;BaseElements&gt;(<wbr>_:<wbr> FlattenBidirectionalCollectionIndex&lt;BaseElements&gt;, rhs: FlattenBidirectionalCollectionIndex&lt;BaseElements&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-baseelements_-flattenbidirectionalcollectionindex-baseelements-rhs_-flattenbidirectionalcollectionindex-baseelements"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;BaseElements&gt;(lhs: FlattenBidirectionalCollectionIndex&lt;BaseElements&gt;, rhs: FlattenBidirectionalCollectionIndex&lt;BaseElements&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-baseelements_-flattencollectionindex-baseelements-rhs_-flattencollectionindex-baseelements">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-baseelements_-flattencollectionindex-baseelements-rhs_-flattencollectionindex-baseelements">func == &lt;BaseElements&gt;(<wbr>_:<wbr> FlattenCollectionIndex&lt;BaseElements&gt;, rhs: FlattenCollectionIndex&lt;BaseElements&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-baseelements_-flattencollectionindex-baseelements-rhs_-flattencollectionindex-baseelements"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;BaseElements&gt;(lhs: FlattenCollectionIndex&lt;BaseElements&gt;, rhs: FlattenCollectionIndex&lt;BaseElements&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-bound_-comparable_-closedinterval-bound-rhs_-closedinterval-bound">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-bound_-comparable_-closedinterval-bound-rhs_-closedinterval-bound">func <wbr>== &lt;Bound : Comparable&gt;(<wbr>_:<wbr> ClosedInterval&lt;Bound&gt;, rhs: ClosedInterval&lt;Bound&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-bound_-comparable_-closedinterval-bound-rhs_-closedinterval-bound"><div class="p">
    <p>Two <code>ClosedInterval</code>s are equal if their <code>start</code> and <code>end</code> are equal.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Bound : Comparable&gt;(lhs: ClosedInterval&lt;Bound&gt;, rhs: ClosedInterval&lt;Bound&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-bound_-comparable_-halfopeninterval-bound-rhs_-halfopeninterval-bound">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-bound_-comparable_-halfopeninterval-bound-rhs_-halfopeninterval-bound">func <wbr>== &lt;Bound : Comparable&gt;(<wbr>_:<wbr> HalfOpenInterval&lt;Bound&gt;, rhs: HalfOpenInterval&lt;Bound&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-bound_-comparable_-halfopeninterval-bound-rhs_-halfopeninterval-bound"><div class="p">
    <p>Two <code>HalfOpenInterval</code>s are equal if their <code>start</code> and <code>end</code> are equal.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Bound : Comparable&gt;(lhs: HalfOpenInterval&lt;Bound&gt;, rhs: HalfOpenInterval&lt;Bound&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-element_-equatable_-element-rhs_-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-element_-equatable_-element-rhs_-element">func <wbr>== &lt;Element : Equatable&gt;(<wbr>_:<wbr> [Element], rhs: [Element])</a>
        
<div class="comment collapse" id="comment-func-eqeq-element_-equatable_-element-rhs_-element"><div class="p">
    <p>Returns <code>true</code> if these arrays contain the same elements.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Element : Equatable&gt;(lhs: [Element], rhs: [Element]) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-element_-equatable_-arrayslice-element-rhs_-arrayslice-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-element_-equatable_-arrayslice-element-rhs_-arrayslice-element">func <wbr>== &lt;Element : Equatable&gt;(<wbr>_:<wbr> ArraySlice&lt;Element&gt;, rhs: ArraySlice&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-element_-equatable_-arrayslice-element-rhs_-arrayslice-element"><div class="p">
    <p>Returns <code>true</code> if these arrays contain the same elements.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Element : Equatable&gt;(lhs: ArraySlice&lt;Element&gt;, rhs: ArraySlice&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-element_-equatable_-contiguousarray-element-rhs_-contiguousarray-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-element_-equatable_-contiguousarray-element-rhs_-contiguousarray-element">func <wbr>== &lt;Element : Equatable&gt;(<wbr>_:<wbr> ContiguousArray&lt;Element&gt;, rhs: ContiguousArray&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-element_-equatable_-contiguousarray-element-rhs_-contiguousarray-element"><div class="p">
    <p>Returns <code>true</code> if these arrays contain the same elements.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Element : Equatable&gt;(lhs: ContiguousArray&lt;Element&gt;, rhs: ContiguousArray&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-element_-hashable_-set-element-rhs_-set-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-element_-hashable_-set-element-rhs_-set-element">func <wbr>== &lt;Element : Hashable&gt;(<wbr>_:<wbr> Set&lt;Element&gt;, rhs: Set&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-element_-hashable_-set-element-rhs_-set-element"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Element : Hashable&gt;(lhs: Set&lt;Element&gt;, rhs: Set&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-element_-hashable_-setindex-element-rhs_-setindex-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-element_-hashable_-setindex-element-rhs_-setindex-element">func <wbr>== &lt;Element : Hashable&gt;(<wbr>_:<wbr> SetIndex&lt;Element&gt;, rhs: SetIndex&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-element_-hashable_-setindex-element-rhs_-setindex-element"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Element : Hashable&gt;(lhs: SetIndex&lt;Element&gt;, rhs: SetIndex&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-element_-range-element-rhs_-range-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-element_-range-element-rhs_-range-element">func == &lt;Element&gt;(<wbr>_:<wbr> Range&lt;Element&gt;, rhs: Range&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-element_-range-element-rhs_-range-element"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Element&gt;(lhs: Range&lt;Element&gt;, rhs: Range&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-key_-equatable-value_-equatable_-key_-value-rhs_-key_-value">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-key_-equatable-value_-equatable_-key_-value-rhs_-key_-value">func <wbr>== &lt;Key :<wbr> Equatable, Value : Equatable&gt;(<wbr>_:<wbr> [Key :<wbr> Value], rhs:<wbr> [Key : Value])</a>
        
<div class="comment collapse" id="comment-func-eqeq-key_-equatable-value_-equatable_-key_-value-rhs_-key_-value"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Key : Equatable, Value : Equatable&gt;(lhs: [Key : Value], rhs: [Key : Value]) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-key_-hashable-value_-dictionaryindex-key-value-rhs_-dictionaryindex-key-value">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-key_-hashable-value_-dictionaryindex-key-value-rhs_-dictionaryindex-key-value">func <wbr>== &lt;Key : Hashable, Value&gt;(<wbr>_:<wbr> DictionaryIndex&lt;Key, Value&gt;, rhs: DictionaryIndex&lt;Key, Value&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-key_-hashable-value_-dictionaryindex-key-value-rhs_-dictionaryindex-key-value"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Key : Hashable, Value&gt;(lhs: DictionaryIndex&lt;Key, Value&gt;, rhs: DictionaryIndex&lt;Key, Value&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-memory_-autoreleasingunsafemutablepointer-memory-rhs_-autoreleasingunsafemutablepointer-memory">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-memory_-autoreleasingunsafemutablepointer-memory-rhs_-autoreleasingunsafemutablepointer-memory">func == &lt;Memory&gt;(<wbr>_:<wbr> AutoreleasingUnsafeMutablePointer&lt;Memory&gt;, rhs: AutoreleasingUnsafeMutablePointer&lt;Memory&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-memory_-autoreleasingunsafemutablepointer-memory-rhs_-autoreleasingunsafemutablepointer-memory"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Memory&gt;(lhs: AutoreleasingUnsafeMutablePointer&lt;Memory&gt;, rhs: AutoreleasingUnsafeMutablePointer&lt;Memory&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-memory_-unsafemutablepointer-memory-rhs_-unsafemutablepointer-memory">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-memory_-unsafemutablepointer-memory-rhs_-unsafemutablepointer-memory">func == &lt;Memory&gt;(<wbr>_:<wbr> UnsafeMutablePointer&lt;Memory&gt;, rhs: UnsafeMutablePointer&lt;Memory&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-memory_-unsafemutablepointer-memory-rhs_-unsafemutablepointer-memory"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Memory&gt;(lhs: UnsafeMutablePointer&lt;Memory&gt;, rhs: UnsafeMutablePointer&lt;Memory&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-memory_-unsafepointer-memory-rhs_-unsafepointer-memory">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-memory_-unsafepointer-memory-rhs_-unsafepointer-memory">func == &lt;Memory&gt;(<wbr>_:<wbr> UnsafePointer&lt;Memory&gt;, rhs: UnsafePointer&lt;Memory&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-memory_-unsafepointer-memory-rhs_-unsafepointer-memory"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Memory&gt;(lhs: UnsafePointer&lt;Memory&gt;, rhs: UnsafePointer&lt;Memory&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-t_-equatable_-t-rhs_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-t_-equatable_-t-rhs_-t">func <wbr>== &lt;T : Equatable&gt;(<wbr>_:<wbr> T?, rhs: T?)</a>
        
<div class="comment collapse" id="comment-func-eqeq-t_-equatable_-t-rhs_-t"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;T : Equatable&gt;(lhs: T?, rhs: T?) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-t_-rawrepresentable-where-t-rawvalue_-equatable_-t-rhs_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-t_-rawrepresentable-where-t-rawvalue_-equatable_-t-rhs_-t">func <wbr>== &lt;T :<wbr> RawRepresentable where T.RawValue : Equatable&gt;(<wbr>_:<wbr> T, rhs: T)</a>
        
<div class="comment collapse" id="comment-func-eqeq-t_-rawrepresentable-where-t-rawvalue_-equatable_-t-rhs_-t"><div class="p">
    <p>Returns <code>true</code> iff <code>lhs.rawValue == rhs.rawValue</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;T : RawRepresentable where T.RawValue : Equatable&gt;(lhs: T, rhs: T) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-t_-strideable_-t-y_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-t_-strideable_-t-y_-t">func <wbr>== &lt;T : Strideable&gt;(<wbr>_:<wbr> T, y: T)</a>
        
<div class="comment collapse" id="comment-func-eqeq-t_-strideable_-t-y_-t"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;T : Strideable&gt;(x: T, y: T) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-t_-optionalnilcomparisontype-rhs_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-t_-optionalnilcomparisontype-rhs_-t">func == &lt;T&gt;(<wbr>_:<wbr> _OptionalNilComparisonType, rhs: T?)</a>
        
<div class="comment collapse" id="comment-func-eqeq-t_-optionalnilcomparisontype-rhs_-t"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;T&gt;(lhs: _OptionalNilComparisonType, rhs: T?) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-t_-t-rhs_-optionalnilcomparisontype">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-t_-t-rhs_-optionalnilcomparisontype">func == &lt;T&gt;(<wbr>_:<wbr> T?, rhs: _OptionalNilComparisonType)</a>
        
<div class="comment collapse" id="comment-func-eqeq-t_-t-rhs_-optionalnilcomparisontype"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;T&gt;(lhs: T?, rhs: _OptionalNilComparisonType) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-value-element_-heapbuffer-value-element-rhs_-heapbuffer-value-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-value-element_-heapbuffer-value-element-rhs_-heapbuffer-value-element">func == &lt;Value, Element&gt;(<wbr>_:<wbr> _HeapBuffer&lt;Value, Element&gt;, rhs: _HeapBuffer&lt;Value, Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-value-element_-heapbuffer-value-element-rhs_-heapbuffer-value-element"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Value, Element&gt;(lhs: _HeapBuffer&lt;Value, Element&gt;, rhs: _HeapBuffer&lt;Value, Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-value-element_-managedbufferpointer-value-element-rhs_-managedbufferpointer-value-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-value-element_-managedbufferpointer-value-element-rhs_-managedbufferpointer-value-element">func == &lt;Value, Element&gt;(<wbr>_:<wbr> ManagedBufferPointer&lt;Value, Element&gt;, rhs: ManagedBufferPointer&lt;Value, Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq-value-element_-managedbufferpointer-value-element-rhs_-managedbufferpointer-value-element"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;Value, Element&gt;(lhs: ManagedBufferPointer&lt;Value, Element&gt;, rhs: ManagedBufferPointer&lt;Value, Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
